
import dingConfig from "../../package/dingConfig";
import UrlUtil from "../../utils/UrlUtil";
import Axios from "../../utils/AxiosUtil"

const axios = new Axios().getAxios();

export default class DingApi {


    /**
     * 获取token
     * @returns {Promise<AxiosResponse<T>>}
     */
    getAccess_Token() {

        return axios.get(UrlUtil(dingConfig.GET_TOKEN, { appkey: dingConfig.appKey, appsecret: dingConfig.appSecret }));
    }

    /**
     * 获取用户信息
     * @param code 小程序的免登码
     * @returns {Promise<AxiosResponse<T>>}
     */
    getUserInfo(code) {
        return axios.get(UrlUtil(dingConfig.GET_USER_INFO, { access_token: global['ding_token'], code: code }))
    }


    //智能人事
    /**
     * 根据员工userid，批量访问员工花名册字段信息。
     * @param {*} userid_list 员工userid列表，最大列表长度：20
     */
    getEmployee_list(userid_list) {
        return axios.post(UrlUtil(dingConfig.EMPLOYEE_LIST, { access_token: global['ding_token'] }), { userid_list: userid_list })
    }

    /**
     * 分页查询企业待入职员工userid列表
     * @param {*} offset   分页游标，从0开始
     * @param {*} size     分页大小，最大20
     */
    getEmployee_Preentry(offset, size) {
        return axios.post(UrlUtil(dingConfig.EMPLOYEE_PREENTRY, { access_token: global['ding_token'] }), { offset: offset, size: size })
    }

    /**
     * 分页查询企业在职员工userid列表。
     * @param {*} status_list 在职员工子状态筛选，其他状态无效。2，试用期；3，正式；5，待离职；-1，无状态
     * @param {*} offset      分页游标，从0开始
     * @param {*} size        分页大小，最大20
     */
    getEmployee_Onjob(status_list, offset, size) {
        return axios.post(UrlUtil(dingConfig.EMPLOYEE_ON_JOB, { access_token: global['ding_token'] }), { status_listL: status_list, offset: offset, size: size })
    }

    /**
     * 分页查询企业离职员工userid列表。
     * @param {*} offset     分页游标，从0开始
     * @param {*} size       分页大小，最大20
     */
    getEmployee_Dismission(offset, size) {
        return axios.post(UrlUtil(dingConfig.EMPLOYEE_DISSMISSION, { access_token: global['ding_token'] }), { offset: offset, size: size })
    }


    /**
     * 根据员工userid列表，批量查询员工的离职信息。传入非离职员工userid，不会返回信息。
     * @param {*} userid_list     员工userid列表，最大列表长度：20
     */
    getDissmission_list(userid_list) {
        return axios.post(UrlUtil(dingConfig.LIST_DISSMISSIOIN, { access_token: global['ding_token'] }), { userid_list: userid_list })
    }

    /**
     * 此接口用于添加人员到企业待入职，并不同步员工详细档案信息。
     * @param {*} entity      职工信息
     */
    addPreentry(entity) {
        return axios.post(UrlUtil(dingConfig.ADD_PREENTRY, { access_token: global['ding_token'] }), entity);
    }

    //用户管理
    /**
     * 创建用户
     * @param {*} entity 
     */
    addUser(entity) {
        return axios.post(UrlUtil(dingConfig.USER_CREATE, { access_token: global['ding_token'] }), entity);
    }

    /**
     * 更新用户
     * @param {*} entity 
     */
    updateUser(entity) {
        return axios.post(UrlUtil(dingConfig.USER_UPDATE, { access_token: global['ding_token'] }), entity);
    }

    /**
     * 删除用户
     * @param {*} userid 
     */
    removeUser(userid) {
        return axios.get(UrlUtil(dingConfig.USER_REMOVE, { access_token: global['ding_token'], userid: userid }));
    }
    /**
     * 获取用户详情
     * @param {y} userid  员工id
     * @param {n} lang    通讯录语言(默认zh_CN，未来会支持en_US)
     */
    getUser(userid, lang) {
        return axios.get(UrlUtil(dingConfig.GET_USER, { access_token: global['ding_token'], userid: userid, lang: lang }));
    }

    /**
     * 获取部门用户userid列表
     * @param {y} deptId 
     */
    getDeptMember(deptId) {
        return axios.get(UrlUtil(dingConfig.GET_DEPT_MEMBER, { access_token: global['ding_token'], deptId: deptId }));
    }
    /**
     * 获取部门用户
     * @param {y} department_id  获取的部门id
     * @param {*} offset         支持分页查询，与size参数同时设置时才生效，此参数代表偏移量
     * @param {*} size           支持分页查询，与offset参数同时设置时才生效，此参数代表分页大小，最大100
     * @param {*} order          支持分页查询，部门成员的排序规则，默认不传是按自定义排序；
     *                              entry_asc：代表按照进入部门的时间升序，
     *                              entry_desc：代表按照进入部门的时间降序，
     *                              modify_asc：代表按照部门信息修改时间升序，
     *                              modify_desc：代表按照部门信息修改时间降序，
     *                              custom：代表用户定义(未定义时按照拼音)排序
     * @param {*} lang           通讯录语言(默认zh_CN另外支持en_US)
     */
    simplelist(department_id, offset, size, order, lang) {
        return axios.get(UrlUtil(dingConfig.GET_SIMPLE_LIST, { access_token: global['ding_token'], department_id: department_id, offset: offset, size: size, order: order, lang: lang }));
    }
    /**
     * 获取部门用户详情
     * @param {y} department_id  获取的部门id
     * @param {*} offset         支持分页查询，与size参数同时设置时才生效，此参数代表偏移量
     * @param {*} size           支持分页查询，与offset参数同时设置时才生效，此参数代表分页大小，最大100
     * @param {*} order          支持分页查询，部门成员的排序规则，默认不传是按自定义排序；
     *                              entry_asc：代表按照进入部门的时间升序，
     *                              entry_desc：代表按照进入部门的时间降序，
     *                              modify_asc：代表按照部门信息修改时间升序，
     *                              modify_desc：代表按照部门信息修改时间降序，
     *                              custom：代表用户定义(未定义时按照拼音)排序
     * @param {*} lang           通讯录语言(默认zh_CN另外支持en_US)
     */
    getUserListbyPage(department_id, offset, size, order, lang) {
        return axios.get(UrlUtil(dingConfig.GET_USER_BY_DEPT, { access_token: global['ding_token'], department_id: department_id, offset: offset, size: size, order: order, lang: lang }));
    }

    /**
     * 获取管理员列表
     */
    getAdmin() {
        return axios.get(UrlUtil(dingConfig.GET_ADMINS, { access_token: global['ding_token'] }));
    }

    /**
     * 获取管理员通讯录权限范围
     */
    getAdminScope() {
        return axios.get(UrlUtil(dingConfig.GET_ADMIN_SCOPE, { access_token: global['ding_token'] }));
    }
    /**
     * 根据unionid获取userid 
     * @param {y} unionid  员工在当前开发者企业账号范围内的唯一标识，系统生成，固定值，不会改变
     */
    getUseridByUnionid(unionid) {
        return axios.get(UrlUtil(dingConfig.GET_USERID_BY_UNIONID, { access_token: global['ding_token'], unionid: unionid }));
    }

    /**
     * 根据手机号获取userid
     * 企业使用此接口可通过手机号获取其所对应员工的userid。
     * @param {*} mobile 手机号码
     */
    getUserIdByMobile(mobile) {
        return axios.get(UrlUtil(dingConfig.GET_BY_MOBILE, { access_token: global['ding_token'], mobile: mobile }));
    }

    /**
     * 获取企业员工人数
     * @param {y} onlyActive  0：包含未激活钉钉的人员数量 1：不包含未激活钉钉的人员数量
     */
    getOrgUserCount(onlyActive) {
        return axios.get(UrlUtil(dingConfig.GET_ORG_USER_COUNT, { access_token: global['ding_token'], onlyActive: onlyActive }));
    }

    /**
     * 未登录钉钉的员工列表(企业使用此接口可查询指定日期内未登录钉钉的企业员工列表 (每天9点后调用接口才能确保获取前一天数据))
     * @param {y} query_date   	20190808  查询日期
     * @param {y} offset         分页数据偏移量，从0开始
     * @param {y} size           每页大小，最大100
     */
    getInactiveUser(query_date, offset, size) {
        return axios.post(UrlUtil(dingConfig.GET_INACTIVE_USER, { access_token: global['ding_token'] }), { query_date: query_date, offset: offset, size: size });
    }


    //部门管理
    /**
     * 创建部门
     * @param {*} entity 
     */
    addDept(entity) {
        return axios.post(UrlUtil(dingConfig.DEPT_CREATE, { access_token: global['ding_token'] }), entity);
    }

    /**
     * 更新部门
     * @param {*} entity 
     */
    updateDept(entity) {
        return axios.post(UrlUtil(dingConfig.DEPT_UPDATE, { access_token: global['ding_token'] }), entity);
    }

    /**
     * 删除部门
     * @param {*} id 
     */
    removeDept(id) {
        return axios.get(UrlUtil(dingConfig.DEPT_REMOVE, { access_token: global['ding_token'], id: id }));
    }

    /**
     * 获取子部门ID列表
     * 注意：该接口能获取到企业部门下的所有直属子部门列表，不受授权范围限制，ISV可以根据该接口完成企业部门的遍历。
     * @param {y} id 父部门id。根部门的话传1
     */
    getDeptIds(id) {
        return axios.get(UrlUtil(dingConfig.LIST_IDS, { access_token: global['ding_token'], id: id }));
    }

    /**
     * 获取部门列表
     * @param {*} id           父部门id（如果不传，默认部门为根部门，根部门ID为1）
     * @param {*} lang         通讯录语言（默认zh_CN，未来会支持en_US）
     * @param {*} fetch_child  是否递归部门的全部子部门，ISV微应用固定传递false
     */
    getDeptList(id, lang, fetch_child) {
        return axios.get(UrlUtil(dingConfig.DEPT_LIST, { access_token: global['ding_token'], id: id, lang: lang, fetch_child: fetch_child }));
    }

    /**
     * 获取部门详情
     * @param {*} id    部门id
     * @param {*} lang  通讯录语言(默认zh_CN，未来会支持en_US)
     */
    getDeptDetail(id, lang) {
        return axios.get(UrlUtil(dingConfig.GET_DEPT_DETAIL, { access_token: global['ding_token'], id: id, lang: lang }));
    }

    /**
     * 查询部门的所有上级父部门路径
     * @param {*} id 希望查询的部门的id，包含查询的部门本身
     */
    listParentDeptsByDept(id) {
        return axios.get(UrlUtil(dingConfig.LIST_PARENT_DEPTS_BY_DEPT, { access_token: global['ding_token'], id: id }));
    }

    /**
     * 查询指定用户的所有上级父部门路径
     * @param {*} userId 
     */
    listParentDepts(userId) {
        return axios.get(UrlUtil(dingConfig.LIST_PARENT_DEPTS, { access_token: global['ding_token'], userId: userId }));
    }

    /**
     * 获取角色列表
     * @param {*} offset   分页偏移，默认值：0
     * @param {*} size     分页大小，默认值：20，最大值200
     */
    getRoleList(offset, size) {
        return axios.get(UrlUtil(dingConfig.ROLE_LIST, { access_token: global['ding_token'], offset: offset, size: size }));
    }

    /**
     * 获取角色下的员工列表
     * @param {*} role_id 角色ID
     * @param {*} offset  分页大小，默认值：20，最大值200
     * @param {*} size    分页偏移，默认值：0
     */
    getRoleSimplelist(role_id, offset, size) {
        return axios.get(UrlUtil(dingConfig.ROLE_SIMPLELIST, { access_token: global['ding_token'], role_id: role_id, offset: offset, size: size }));
    }

    /**
     * 获取角色组
     * @param {*} group_id  角色组的Id
     */
    getRoleGroup(group_id) {
        return axios.get(UrlUtil(dingConfig.GET_ROLE_GROUP, { access_token: global['ding_token'], group_id: group_id }));
    }

    /**
     * 获取角色详情
     * @param {*} roleId   角色Id
     */
    getRoleDetail(roleId) {
        return axios.get(UrlUtil(dingConfig.GET_ROLE, { access_token: global['ding_token'], roleId: roleId }));
    }

    /**
     * 创建角色
     * @param {*} entity 
     */
    addRole(entity) {
        return axios.post(UrlUtil(dingConfig.ADD_ROLE, { access_token: global['ding_token'] }), entity);
    }
    /**
     * 更新角色
     * @param {y} entity 
     */
    updateRole(entity) {
        return axios.post(UrlUtil(dingConfig.UPDATE_ROLE, { access_token: global['ding_token'] }), entity);
    }

    /**
     * 删除角色
     * @param {y} role_id   角色id
     */
    removeRole(role_id) {
        return axios.post(UrlUtil(dingConfig.DELETE_ROLE, { access_token: global['ding_token'] }), { role_id: role_id });
    }

    /**
     * 创建角色组
     * @param {y} name   角色组名称
     */
    addRoleGroup(name) {
        return axios.post(UrlUtil(dingConfig.ADD_ROLE_GROUP, { access_token: global['ding_token'] }), { name: name });
    }

    /**
     * 批量增加员工角色
     * @param {*} roleIds  角色id list，最大列表长度：20
     * @param {*} userIds  员工id list，最大列表长度：100
     */
    addRolesForEmps(roleIds, userIds) {
        return axios.post(UrlUtil(dingConfig.ADD_ROLES_FOREMPS, { access_token: global['ding_token'] }), { roleIds: roleIds, userIds: userIds });
    }

    /**
     * 批量增加员工角色
     * @param {*} roleIds  角色id list，最大列表长度：20
     * @param {*} userIds  员工id list，最大列表长度：100
     */
    removeRolesForEmps(roleIds, userIds) {
        return axios.post(UrlUtil(dingConfig.REMOVE_ROLES_FOREMPS, { access_token: global['ding_token'] }), { roleIds: roleIds, userIds: userIds });
    }

    /**
     * 设定角色成员管理范围
     * @param {*} userid 
     * @param {*} role_id 
     * @param {*} dept_ids 
     */
    setRoleUpdate(userid, role_id, dept_ids) {
        return axios.post(UrlUtil(dingConfig.ROLE_SCOPE_UPDATE, { access_token: global['ding_token'] }), { userid: userid, role_id: role_id, dept_ids: dept_ids });
    }

    //外部联系人

    /**
     * 获取外部联系人标签列表
     * @param {*} offset 
     * @param {*} size 
     */
    listLabelGroups(offset, size) {
        return axios.post(UrlUtil(dingConfig.LIST_LABEL_GROUPS, { access_token: global['ding_token'] }), { offset: offset, size: size });
    }

    /**
     * 获取外部联系人详情  
     * @param {*} user_id   	用户id
     */
    getExtcontactDetail(user_id) {
        return axios.post(UrlUtil(dingConfig.EXTCONTACT_LIST, { access_token: global['ding_token'] }), { user_id: user_id });
    }

    /**
     * 添加外部联系人
     * @param {*} contact 
     */
    createExtcontact(contact) {
        return axios.post(UrlUtil(dingConfig.CREATE_EXTCONTACT, { access_token: global['ding_token'] }), contact);
    }

    /**
     * 更新外部联系人
     * @param {*} contact 
     */
    updateExtcontact(contact) {
        return axios.post(UrlUtil(dingConfig.UPDATE_EXTCONTACT, { access_token: global['ding_token'] }), contact);
    }

    /**
     * 删除外部联系人
     * @param {*} user_id 
     */
    removeExtcontact(user_id) {
        return axios.post(UrlUtil(dingConfig.DELETE_EXTCONTACT, { access_token: global['ding_token'] }), contact);
    }

    //消息通知
    /**
     * 发送工作通知消息
     * @param {\} agent_id     应用agentId 
     * @param {*} msg          消息内容，消息类型和样例参考“消息类型与数据格式”。最长不超过2048个字节
     * @param {*} userid_list  接收者的用户userid列表，最大列表长度：100
     * @param {*} dept_id_list 接收者的部门id列表，最大列表长度：20,  接收者是部门id下(包括子部门下)的所有用户
     * @param {*} to_all_user  是否发送给企业全部用户
     */
    corpConversation(agent_id, msg, userid_list, dept_id_list, to_all_user) {
        return axios.post(UrlUtil(dingConfig.SEND_WORK_NOTICE, { access_token: global['ding_token'] }), { agent_id: agent_id, msg: msg, userid_list: userid_list, dept_id_list: dept_id_list, to_all_user: to_all_user });
    }


    /**
     * 查询工作通知消息的发送进度
     * @param {*} agent_id     发送消息时使用的微应用的id  
     * @param {*} task_id      发送消息时钉钉返回的任务id
     */
    getSendProgress(agent_id, task_id) {
        return axios.post(UrlUtil(dingConfig.GET_SEND_PROGRESS, { access_token: global['ding_token'] }), { agent_id: agent_id, task_id: task_id });
    }



    /**
     * 查询工作通知消息的发送结果
     * @param {*} agent_id      微应用的agentid
     * @param {*} task_id       异步任务的id
     */
    getSendResult(agent_id, task_id) {
        return axios.post(UrlUtil(dingConfig.GET_SEND_RESULT, { access_token: global['ding_token'] }), { agent_id: agent_id, task_id: task_id });
    }


    /**
     * 工作通知消息撤回
     * @param {*} agent_id      微应用的agentid
     * @param {*} msg_task_id   异步任务的id
     */
    recall(agent_id, msg_task_id) {
        return axios.post(UrlUtil(dingConfig.Recall, { access_token: global['ding_token'] }), { agent_id: agent_id, msg_task_id: msg_task_id });
    }


    /**
     * 发送群消息
     * @param {*} chatid        群会话的id，可以在调用创建群会话接口的返回结果里面获取，也可以通过dd.chooseChat获取
     * @param {*} msg           消息内容，消息类型和样例可参考“消息类型与数据格式”文档
     */
    chatSend(chatid, msg) {
        return axios.post(UrlUtil(dingConfig.CHAT_SEND, { access_token: global['ding_token'] }), { chatid: chatid, msg: msg });
    }




















}
